home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Almathera Ten Pack 3: CDPD 3
/
Almathera Ten on Ten - Disc 3: CDPD3.iso
/
scope
/
051-075
/
scopedisk53
/
resource
/
resource.doc
< prev
next >
Wrap
Text File
|
1995-03-18
|
45KB
|
968 lines
Documentation for ReSource (C) 1988 Glen McDiarmid
TO GET STARTED QUICKLY:
****************************************************************
Don't forget to put arp.library in your LIBS: directory!
****************************************************************
Run ReSource from a CLI, and when you are presented with a file
requester, select an executable file to disassemble (anything
within your "C" directory will do nicely). Alternatively, you
may disassemble Kickstart by supplying a filename of "*". Once
loaded, you may scroll forwards/backwards through the file with
the down/up arrow keys. Using the shift key with the up/down
arrow keys will move you faster through the file. You may also
use mouse-scrolling, by holding the left mouse button down, then
SLOWLY moving the mouse forwards or backwards, depending on which
way you want to move through the file. While moving forwards
with the mouse, holding the left Amiga key down will start the
label creation process, in a controlled manner. When labels are
created, ReSource decides which type of data is being labelled,
and it is generally correct in its judgement. Once you have made
some labels, select the 'Fill-in data types' menu item, under the
"DISPLAY" menu. Once you have created labels from all areas of
code, select 'Fill-in data types' again, and you may then scroll
through the file, checking for yourself that all is in order
(there will occasionally be cases where ReSource made an
incorrect judgement, and code made be shown as ASCII, or vice-
versa). Use one of the "Set data types" sub-menu selections, to
set the correct data type. Remember to use the "Fill-in data
types" command again, so that code and data are shown correctly.
If you are working on a large file, you may wish to save your
work, so that you can continue it at a later time. To do this,
select "save all" under the "PROJECT" menu. When you use the
"save all" option, you are creating a "ReSource file", as it is
only useable by ReSource. By default, the filename will end in
".RS". You may change this if you like.
****************************************************************
ABOUT RESOURCE:
ReSource is an interactive disassembler. To give you an idea of
which files can and cannot be disassembled, the following is a
list of files from a Workbench 1.2 disk, that ReSource can
disassemble:
C directory: all
L directory: all
LIBS directory: all
DEMOS directory: Boxes, Dots, Spots
SYSTEM directory: CLI, DiskCopy, Format, GraphicDump, IconEd,
Say, SetMap.
DEVS directory: all keymaps, all printer drivers, everything
ending in ".device".
FONTS directory: everything within sub-directories
(topaz/11,emerald/17, etc.)
UTILITIES directory: Calculator, Notepad
ROOT directory: Preferences, Clock
I personally wanted a good disassembler to fix bugs in many of
the public domain programs that I use. I was also interested in
getting to know how C programs worked, at the assembly language
level. ReSource is the result of 3 and a half months full-time
effort; during this time I have been using each version
extensively. I am very impatient when it comes to waiting for
programs to complete operations, this has resulted in a
disassembler that is extremely fast, at the cost of memory usage.
Even though ReSource was written purely in assembly language, it
uses lots of memory, especially when disassembling large
programs. Generally, if you have 1.5 Megs of memory, you will be
able to disassemble most programs. To disassemble Kickstart, you
will require at least 2 Megs if you have a hard drive, or 3.5
Megs if you do not have a hard drive. As a further condition,
there must be at least 1.1 Megs of contiguous memory, for the
attributes table.
****************************************************************
GENERAL USAGE:
****************************************************************
Don't forget to put arp.library in your LIBS: directory!
****************************************************************
Disassembling a program consists of examining a load file
(sometimes called "executable" or "object" files), and from the
information contained therein, create a text file (assembler
source code) which, when assembled, can be used identically to
the original load file. It takes many, often hundreds, of hours
of painstaking work to become proficient at disassembling even a
small program manually. Even experts can spend many hours
disassembling very small programs, while large Amiga programs may
take weeks. From now on, this will not be the case with Amiga
programs. Large programs (100K or larger) can be disassembled in
an evening, while small programs (such as CD, PROMPT, AVAIL,
ECHO, FILENOTE, etc., take around 3-5 seconds to produce re-
assemblable source code.
As an example, let's disassemble LoadWB, which you'll find in the
C directory of just about any booting disk, including a standard
Workbench disk (make sure that it comes from a V1.2 Workbench,
not 1.1 or 1.3! At the CLI prompt, type:
RUN RS C:LOADWB
You don't really have to use the "run" command, but I find it
convenient, so maybe you will too. When ReSource starts running,
it will load the file "loadwb" from the C directory, and
disassemble the first page for you. We can now start the label-
creation process. This involves getting ReSource to examine
lines of code, and on each line, if there is any reference to
another part of the program, ReSource will decide which type of
data is being referenced. For example, the first line of code in
our program is:
MOVE.L SP,START+$01E0
Okay, go to the menus, under "LABELS" menu, you'll find "Create
single". A sub-menu box will pop out, and from this, select
"Address symbol dest". Now, the first line of code in our
program should be:
MOVE.L SP,lbL0001E0
Now, scroll forward through the program (using shift-down arrow),
until you find a line starting with "lbL0001E0":
lbL0001E0 dc.l 0
The label "lbL0001E0" is something that ReSource has just now
created. In this case, ReSource decided that the data being
referenced was a Longword, hence the "L" in "lbL0001E0". If it
was code that was being referenced, the label would have been
"lbC0001E0" instead. There are five type of data recognized by
ReSource:
ASCII - CODE - BYTES - WORDS - LONGWORDS
The processes involved in deciding which type of data is being
referenced is quite complex, and such things as the surrounding
code/data, the relative position of reloc32 areas, hunk types,
relative position from the start of a hunk, the actual
information being referenced, whether the data is word/longword
aligned, the actual instruction from which the reference was
derived, the proximity of other labels, and what data types they
refer to, all take part in the decision-making process. If the
first line of code in out program had been:
MOVE.W SP,START+$01E0
, then the label created would have been "lbW0001E0" instead, and
the data type at this label would have been set to words. If you
like, you can manually set the data type of any byte in the
program, by selecting a sub-menu item from the "Set data type"
menu item, under "DISPLAY" in the menus. This will not create a
label, but it will re-define the current byte within the file (on
the top line of the display) as being ASCII, CODE, or whichever
data type you selected. Generally, this is not required, except
sometimes in large programs, but after letting ReSource do its
thing first. If you like doing things with the mouse, you can
even set the data type this way. Once you have mastered mouse
scrolling, try holding down the left-shift key while still
holding down the left mouse button. This will display everything
as if it were set to the data type BYTES. Holding down the left
alt key will display everything as if it were set to ASCII.
Similarly, the left shift and left alt keys held down together to
show everything in WORDs; hold down the ctl key and everything
will be displayed as CODE. Hold down all three, and everything
will be shown as LONGWORDS. If you decide make this data type
permanent, press the menu button, and the current position within
the program will be set to the data type currently being
displayed. By holding down the right alt key, you can remove
labels while scrolling.
Now scroll back to the start of the program (select "Start of
file" submenuitem, under the "Absolute" menuitem under the
"CURSOR" menu). Alternatively, just use the up arrow key, to
scroll back slowly. Look in the screen title bar to find out how
far you are from the start of the file. This offset is being
shown in hexdecimal. Now, use the down arrow key to scroll
forward to the second line of code in our program:
MOVE.L D0,START+$01E8
Again, select the "Address symbol dest" submenuitem, to create
the label "lbL0001E8". Do this to as many lines of code as you
like, so that you become familiar with the label creating
process. What you have just done can be done far quicker, by
using the "Create multiple" label functions. Firstly, select the
"Open" menuitem, under "PROJECT" in the menus. Again, we will
use "LoadWB" from within your C directory. Once it is loaded,
look in the menu under "LABELS", go to the menuitem "Create
multiple", and select "All" from the sub-menuitem box. Around
three quarters of a second later, you should be at position
"0001C8" relative from the start of the file. The top line of
the display should read:
lbL0001C8 dc.l 0
If this is correct, you should now find some more code to make
labels from. To do this, you could use the down arrow key to
scroll forward, the shift-arrow key to page forward, or let
ReSource do the searching for you, by selecting "Next unparsed
code" from the "CURSOR" menu. If there is no more code that has
not been parsed, you will be returned to the start of the file.
However in this case, there is more code to parse, so go to it!
When eventually "Next unparsed code" returns you to the start of
the file, slowly scroll through the file, and examine as you go.
You should find some ASCII, but it isn't being shown like it
really should. This is the time to select "Fill-in data types"
from the "DISPLAY" menu.
Okay, now the program is completely disassembled right? Well,
nearly. If you followed the above instructions to the letter,
there will be once more section of code that labels have NOT been
created from. This will be at offset "000584". This is because
this area of the program was only recognized as code, after it
had been skipped over. In fact, the only reference to this part
of the program is made at offset "0005E6", and the code is:
JSR lbC000584
Again, create multiple labels within this area, and search for
the next unparsed code. If you select "Next unparsed code" while
at the start of the file, and ReSource cannot find any, then
again select "Fill-in data types", and this should complete the
disassembly of LoadWB.
Actually, at this point, I generally will change some of the
labels, so that they are meaningful. For instance, the first
line of code places the contents of the SP register at
"lbL0001E0", right? Scroll forward to the line starting with
this label, and select "Address symbol" submenuitem, from the
"Create single" menuitem, under "LABELS" menu. You will be
requested to input a new label name. I would call this label
"SaveSP"; you call it anything you like. Now, scroll backwards
to the offset "0000D2":
MOVE.L SaveSP,SP
We didn't change this line, so what is going on? You have just
witnessed one of the major benefits of an interactive
disassembler; any label changes you make are reflected throughout
the entire program, instantly. Anywhere else in the program that
you can place a meaningful label, will help greatly in
recognizing how a program executes, without actually executing
it. Also, if you wish to make changes to the source, meaningful
labels help greatly. While still within ReSource, you may add
comments, both full-line, and end-of-line, to aid in the
understanding of the program.
****************************************************************
EXPLANATION OF FUNCTIONS:
The following section gives details of the uses of each function,
as they are shown in the menus. Not all functions are enabled in
all versions, this is especially so in V0.x (demo version).
PROJECT/Abort:
Use this to abort out of most functions.
PROJECT/Open:
Requests you to select a file to open. Use this function
to load executable files, as well as ReSource files.
PROJECT/Restore:
Same as PROJECT/Open, but assumes that you wish to open
the same file as you last opened.
PROJECT/Save .RS:
Saves the file that you are currently working on, in a
form useable only by ReSource. Also saves the current location
with the file. To continue work on the file later, use the
PROJECT/Open function.
PROJECT/About:
Gives you some specific details about the version of
ReSource that you are currently using.
PROJECT/Quit:
Asks you for confirmation, then quits without saving.
OUTPUT/Save .asm:
Saves current file in assembler source code format.
OUTPUT/O/P directory:
Requests you to supply the name of a directory that .asm
files will be sent to (you can still change this when you supply
the name of the output file, it just makes it easier if you are
disassembling many files).
OUTPUT/Tabs:
Use to select between real tabs (ASCII value 9) and
spaces being used in the output source code.
DISPLAY/Hiliting:
Selective use of inverse video can be useful to give
extra information about parts of a file. For instance, you may
want to get a quick idea of which parts of a file came from a BSS
hunk, rather than CODE or DATA hunks. To do this, select
DISPLAY/Hiliting/BSS hunks.
DISPLAY/Hiliting/Reloc32:
I find it particularly useful to hilite the Reloc32
areas, especially when determining data types (reloc32 is
documented in the Amiga technical reference manual. It
ultimately means that a number of longwords in the file point to
somewhere in memory, relative to the start of one of the hunks of
the file. This almost always end up being somewhere within the
file. This information helps ReSource greatly when defining data
types).
DISPLAY/Hiliting/Chip load hunks:
Certain hunks of a load file may only be loaded into chip
memory. Usually, graphics, especially sprites, will be included
in one of these special hunks, and this information is sometimes
useful, especially when you intend to re-assemble the file.
"Chip load hunks" will hilite these hunks for you, also fast load
hunks may be hilited.
DISPLAY/Hiliting/Symbol scan:
For all lines that you have created labels from, these
lines will be hilited.
DISPLAY/Hiliting/Data type uncertain:
For most labels that ReSource creates automatically, it
is certain of the data type that it assigns. Sometimes though,
it cannot be 100% sure, and this function will hilite all lines
that fall into this category.
DISPLAY/Hiliting/Data type known:
Similar to above function, only the lines where the
ReSource was certain of the data type, will be hilited.
DISPLAY/Hiliting/Internally produced refs:
All lines which have a label that was created by
ReSource, will be hilited.
DISPLAY/Set data type:
When you are certain of which type of data that you are
looking at, select from one of the submenu items:
Code - Ascii - Bytes - Words - Longwords
DISPLAY/Set numeric base:
By default, all numbers are shown in hexdecimal (base
16). You can change this to ASCII, DECIMAL or BINARY on any line
by selecting from the appropriate sub-menu item. To change back
to HEXDECIMAL, simply select the same function again. It is
possible to change the default to decimal for numbers less than
16, or less than 10, using the decimal conversion function (see
below).
DISPLAY/Decimal conversion:
By default, all numbers are show in hexdecimal. You can
have numbers less than 16, or numbers less than 10, shown in
decimal throughout the file, by selecting one of the appropriate
sub-menu items.
DISPLAY/Block-fill:
This function will probably not get much use. It can be
used to set the data type of blocks of data. For example, in a
particular file, there may a large section of code, maybe 100K or
so, and rather than rely on ReSource to make the correct
judgement of data type every time, you can set the data type of
every byte in the file to code, by doing the following: Scroll
to the start of the block. Set the data type here to CODE.
Select the "CURSOR/Remember" function. Now, scroll to the end of
the block (don't use any function that stacks the cursor
position, such as "CURSOR/Absolute/End of file", as this will
change the remembered offset. When you get to the end of the
block, select the "DISPLAY/Block-fill" function. The type of
data at the start of the block will be echoed throughout the
entire block.
DISPLAY/Fill-in data types:
This function has several uses, and will be one of the
most-used functions. To understand what this function does, you
will need to know how ReSource keeps track of data types (see
section "Inside ReSource"). Suffice it to say, when you set the
data type anywhere within a file, that data type is immediately
echoed forward, to a maximum of several hundred bytes, but will
not change any other places where the data type has already been
set, or where there is an address symbol (label) on a line.
Where there is large areas of a file where the data type has not
been set, this function attempts to set the data type where
appropriate. All of the above is done in the first pass. On the
second pass, the length of each line is set, this is particularly
useful where there is large areas of ASCII. This function should
always be used just before saving a file as source code (OUTPUT/
Save .asm).
DISPLAY/Set counter:
The current offset in a file is always shown in the title
bar, in hexdecimal. This is normal zero at the start of the
file. You can change this, so that it is zero at somewhere other
than the start of the file, by using this function. You may use
this function to measure the size of a hunk, for example. To
"reset" the counter, use the function "DISPLAY/Reset counter".
DISPLAY/Reset counter:
Resets the offset counter, in the title bar, so that it
is zero at the start of the file. See "DISPLAY/Set counter".
SYMBOLS:
When you create an assembly-language program, if you wish
to allocate some memory, you will probably have somewhere in you
file:
JSR _LVOAllocMem(A6)
If you were to disassemble this program, this line of code would
be show as:
JSR -$0228(A6)
, which is not particularly meaningful. When disassembling a
program, if you can figure out which library base the A6 register
is pointing to (in this case, it would be the EXEC library), you
can get ReSource to make the appropriate substitution. In this
example, you would select "SYMBOLS/E-G/Exec library". Following
is another example:
MOVE.L #$00038007,D7
MOVE.L 4,A6
JSR -$006C(A6)
The second line loads Execbase into the A6 register, so you
should move the third line to the top of the display, and select
"SYMBOLS/E-G/Exec library". Scroll back a couple of lines, and
you would see:
MOVE.L #$00038007,D7
MOVE.L 4,A6
JSR _LVOAlert(A6)
If you looked at the documentation for the Exec "Alert" call, you
would find that one of the input parameters is required to be in
the D7 register. If you then looked in the include file "exec/
alerts.i", you would find that the number "$00038007" consists of
three values, OR'd together:
AT_Recovery - AG_OpenLib - AO_DOSLib
There is no need to go to all this trouble, simple line up the
first line with the top of the display, and select "SYMBOLS/A-B/
Alert codes", and ReSource will make the appropriate
substituition for you:
MOVE.L #AT_Recovery!AG_OpenLib!AO_DOSLib,D7
MOVE.L 4,A6
JSR _LVOAlert(A6)
Now isn't that much better than the original? There are over 200
different classes of symbols that ReSource can substitute (only
two are enabled in the demo version).
Consider the following lines of code:
MOVE.L 4,A4
MOVE.L #$100000,$003A(A4)
Let's assume that you wish to substitute a symbol for the "$003A"
in the second line of code. By default, ReSource will attempt to
substitute a symbol for the first number that it finds in a line
of code. To change this, select "SYMBOLS/Set source/dest/
Destination", and then the appropriate symbol base (Exec library,
in this example).
CURSOR/Remember:
Where it is possible to lose your place within a file by
using certain functions (such as "CURSOR/Absolute/Start of
file"), ReSource will store the current cursor location, just
prior to the function being executed. To return to the previous
cursor location, select "CURSOR/Absolute/Previous location".
When you plan to return to a specific place within the file,
using this function will make it easier to do so. It simply
stores the cursor location on a stack, for later access.
CURSOR/Clear Loc stack:
The cursor location stack can contain up to 256
locations. If more locations are "pushed" onto this stack, the
location at the bottom (the oldest) are forgotten. This function
will empty the cursor location stack.
CURSOR/Relative/Next byte:
The cursor position is incremented.
CURSOR/Relative/Previous byte:
The cursor position is decremented.
CURSOR/Relative/Next line:
Scroll forward by one line.
CURSOR/Relative/Previous line:
Scroll backwards by one line. The length of a line will
depend on what the data type is. Until you first use "DISPLAY/
Fill-in data types", backwards scrolling may not be quite what
you expect.
CURSOR/Relative/Next page:
Scroll forward by one page. This will be approximately
20 lines.
CURSOR/Relative/Previous page:
Scroll backwards by one page. This will be approximately
20 lines.
CURSOR/Relative/Skip forward:
Scroll forward by approx 4096 bytes ($1000).
CURSOR/Relative/Skip Backward:
Scroll backward by approx 4096 bytes ($1000).
CURSOR/Relative/Next unparsed code:
Scroll forward to the next line of code, that has been
labelled, and that has not been parsed for labels yet.
CURSOR/Relative/Next data type change:
Scroll forward to the next byte whose data type is
different to the data type of the current byte.
CURSOR/Relative/Previous data type change:
Scroll backward to the first byte found whose data type
is different to the data type of the current byte.
CURSOR/Relative/Next uncertain data type:
Scroll forward to the next position within the file that
ReSource has labelled, but at the time was not quite sure of
which data type to set.
CURSOR/Relative/Next backward reference:
Using the "CURSOR/Absolute/Backward reference" function,
it is possible to find the first reference to the current
position within the file. Use this function to find further
references to the same position. The search function could be
used instead, but may also find references within comments,
mnemonics, or even within other labels.
CURSOR/Absolute/End of file:
Move cursor to the last line of the file.
CURSOR/Absolute/Start of file:
Move cursor to the first line of the file.
CURSOR/Absolute/Forward reference:
I'll use an example to explain this one:
JSR lbC0132DE
If you wanted to "check out" the subroutine at label
"lbC0132DE", but later return to the current cursor position,
simply scroll until this line is on the top line of the display,
and select "CURSOR/Absolute/Forward reference". The current
cursor location is stored (on a stack), so that you can return to
this cursor position, using the "CURSOR/Absolute/Previous
location" function.
CURSOR/Absolute/Forward reference:
This is similar to the "CURSOR/Absolute/Forward
reference" function, except that on a line such as:
MOVE.L lbL00DEAF,lbL00BEEF
the second label is used (lbL00BEEF), rather than the first
(lbL00DEAF).
CURSOR/Absolute/Backward reference:
Use to find the first reference made to the current
cursor position. See "CURSOR/Absolute/Next backward reference".
CURSOR/Absolute/Previous location:
With many functions that change the cursor location
substantially, the current cursor position is stored on a stack.
To "pop" the last saved location, use this function.
CURSOR/Scrolling speed:
You can select from five scrolling speeds. This relates
to the speed/smoothness of scrolling when using the "CURSOR/
Relative/Next line" and "CURSOR/Relative/Previous line" functions.
CURSOR/Search/Set search pattern:
You will be requested to input a string. Unless you
select "CANCEL", the string you input will be searched for
immediately, starting at the current cursor position. Normal ARP
wildcards are accepted:
(a|b|c) Will match one of a, b or c.
These can be patterns.
? Matches any single character
#<pat> Pattern repeated 0 or more times,
in particular, #? matches anything.
[char] A set of characters, for example,
[abc] or [a..c] specify the same set.
[^char] Match everything but this set of characters.
* 0 or more occurances of any character.
CURSOR/Search/Find next occurence:
Using the current search string, search forward from the
current cursor position. See "CURSOR/Search/Set search pattern".
LABELS/Create single/End-of-line comment:
You will requested for a string, which will be shown at
the end of the current line, starting with " ; ".
LABELS/Create single/Full-line comment:
You will requested for a string, which will be shown on a
seperate line, previous to the current line, starting with "; ".
Generally, this will be used to add a comment too long to put at
the end of the current line.
LABELS/Create single/Address symbol:
You will be requested for a string, which will become the
label for the current line. Any references to the current line
will use the new label name, throughout the entire file,
immediately.
LABELS/Create single/Address symbol dest:
The current line of code will be searched for references
to positions within the current file. If any are found, ReSource
will make a decision on which type of data is at the position
referenced, it will then set the data type, and create a label at
that offset. This new label will be immediately used for all
references to that location, which of course includes the
reference within the current line. If the current line is not
being shown as code, or if there is no references, or there is a
reference, but it is outside of the range of the current file,
then this function will do nothing. Normally, this function will
only be used within macros, as it is easier and quicker to hold
down the left Amiga key, while holding down the left mouse
button, possibly while scrolling also.
LABELS/Create single/Value symbol:
Following is several examples of address symbols
(labels), and value symbols.
lbC000124 MOVE.B bm_Depth(A0),D0
In the above line, "lbC000124" is an address symbol, and
"bm_Depth" is a value symbol.
MOVE.B bm_Depth(A0),DepthByte
In this line, "DepthByte" is and a reference to an address symbol
(label), NOT a value symbol.
MOVE.L #MEMF_CLEAR,D1
In this line, "MEMF_CLEAR" is a value symbol. If a value symbol
had not been created for this line, the line would be:
MOVE.L #$10000,D1
Address symbols (labels) always equate to a position within the
file, while value symbols may equate to any value at all.
Unfortunately, there is several cases where a value symbol may
equate to a position within the file:
MOVEA.L #lbC000134,A0
JSR (A0)
In this case, you may assign a value symbol, in which case the
value symbol will be shown, not the label name of the position
within the file that the instruction refers to. If however, you
later remove the value symbol, the then label name of the line
being referenced (at present, this is "lbC000134"), will be
shown. When you create an address symbol or value symbol, the
name is NOT checked for validity, it is up to you to decide
whether or not the assembler that you will be using will accept
the resulting code. For example:
MOVE.L #FFFFFFFA,D0
may be changed to:
MOVE.L #-6,D0
by creating a value symbol "-6". Virtually any value can be
given a value symbol, including bit numbers:
BTST #AFB_68020,$0124(A6)
LABELS/Create single/Value symbol - dest:
Similar to "LABELS/Create single/Value symbol" function,
except that the second reference within the current line will
used, rather than the first:
BTST #4,SysFlags(A6)
LABELS/Edit single:
All of these functions are identical to their
counterparts in "LABELS/Create single", except that if their is
an existing label/symbol/comment, you will be requested to edit
it, rather than create a new one. Given the editing capabilities
of a string gadget, the create functions are a luxury really,
although I find that when I change a label/symbol/comment, I
generally make it nothing like the original, hence I nearly
always use the create functions, to save me the trouble of
pressing "rAmiga-X".
LABELS/Remove single/Address symbol:
Remove any address symbol (label) for the current line.
LABELS/Remove single/Value symbol:
Remove ALL value symbols in the current line.
LABELS/Remove single/End-of-line comment:
Remove any end-of-line comment for the current line.
LABELS/Remove single/All:
Remove all symbols and comments for the current line.
LABELS/Create multiple/Reloc32 all:
For each reloc32 pointer within the current file,
determine the data type being referenced, set the data type, and
create a label at that address. This function should be used
with caution, as when it makes a decision on the data type, it
does not have the same information available as when creating
labels normally. This function should be most useful after
creating labels from all code in a program, where there is one or
more large tables of pointers.
LABELS/Create multiple/All:
Starting at the current address, the "LABELS/Create
single/Address symbol dest" function is executed, and if ReSource
thinks that there was valid code in the current line, the
"CURSOR/Relative/Next line" function is executed, and the entire
function loops, otherwise the "PROJECT/-=Abort=-" function is
executed. This function can make the disassembly process very
fast, the disadvantage being that there is a very slight chance
that what ReSource thinks is valid code, is really ascii, and
invalid labels will be created.
SPECIAL FUNCTIONS/Repeat last command:
Execute the last function that was executed. This does
not include most cursor movements. By rebinding this function to
an easily-accessed key, such as the space bar, (and saving the
keytable) there should be much less need to rebind keys often.
SPECIAL FUNCTIONS/Convert xx(A4) EA's
These functions were specifically designed to be used
when disassembling 'C' programs, in which the A4 register is used
as a base register for accessing data, throughout all or most of
the program. Let's use an example program here:
SECTION test000000,CODE
LEA START+$11E,A4
LEA 0(A4),A1
MOVE.L $000C(A4),D0
.... rest of code
SECTION test00011E,DATA
dc.b 'dos.library',0
dc.l $00010001
END
In the above program, the A4 register will point to the start of
the data segment. There are three ways to tell ReSource where
the A4 register will point to; in the above example, the "This
operand" function could be used with the cursor at start of file,
or the "This address" function could be used with the cursor at
offset $00011E, or the "Specify" function could be used, suppying
a parameter of "11E". Basically, with this function, you are
telling ReSource where, relative to the start of the program, the
A4 register can be assumed to be pointing. After you do this,
any effective address that involves a word offset to the A4
register, will be shown as an absolute address. Thus, the
example program above will appear as:
SECTION test000000,CODE
LEA START+$011E,A4
LEA START+$011E,A1
MOVE.L START+$012A,D0
.... rest of code
SECTION test00011E,DATA
dc.b 'dos.library',0
dc.l $00010001
END
The advantage here is that labels can automatically be created
where they could not before. If this conversion process is not
used, it is likely that the program will not successfully re-
assemble, as different assemblers assemble the same source code
into different opcodes. For example, the assembler that I
normally use does virtually no optimizing, and so the resulting
program is often larger than the original, even if I did not
modify the source code. For example:
MOVE.L 4,A6
If absolute long addressing is used, the instruction above will
be 6 bytes long, whereas if absolute short addressing is used, it
will be only 4 bytes long. Where you wish to do EA conversions
in only a portion of a program, you can set the lower and upper
limits.
Changing to absolute EA's will increase the size of the resulting
program, unless you convert back to relative addressing, within
the source code. I believe that one of the features of BLINK
(from the Software Distillery) can help to make this conversion.
SPECIAL FUNCTIONS/Convert specific EA's:
Please read and understand the "SPECIAL FUNCTIONS/Convert
xx(A4) EA's" functions first! Where you want to do specific EA
conversions, use "Set base #1" (or #2, or #3), when the cursor is
the same as where the base register (whatever that is, it does
not have to be A4 this time) can be assumed to point to.
Assuming that you set base #1, and it is the A5 register that is
being used as a base register, you will then use the "Convert W/
Base #1" function to convert lines like:
MOVE.L $0032(A5),A6
.. into:
MOVE.L lbL0014AC(A5),A6
Note here that there has not actually been an EA conversion, but
a label has been created, the data type at label "lbL0014AC" has
been determined and set, and a value symbol ("lbL0014AC") has
been created for this line. It is up to you then to make the
necessary changes to the resulting source code, if re-assembling
is required. Whereas the "Convert xx(A4) EA's" function converts
immediately and automatically, you must use the "Convert W/Base
#1" function on each line that you want converted. If you wish
to convert a destination address, first use the "SYMBOLS/Set
source/dest/Destination" function first.
MACROS:
There are currently twelve user-definable macros
available in ReSource. To start macro #1, select "MACROS/Start/
#1", select the functions to be included in the macro (you can
use the menus, or press keys, it's all the same thing to the
macro). When you are done, select "MACROS/Start/#1" again, to
end the macro. To run the macro, select "MACROS/Execute/#1".
The display is always refreshed during the defining of a macro,
however it is not during the execution. At the end of a macro,
the display is always refreshed. You may nest macros, but you
should not use recursion. If ReSource finds that the nesting
level has exceeded 40, the macro will be abandoned.
Macro files can be saved and re-loaded. When ReSource
first starts up, it looks for "S:RS.macros". If it finds it, it
will load it, and execute macro #12 immediately (that is why
macro #12 is hilited in the menus). This is used to configure
ReSource. Just start macro #12, set what option you want, end
macro #12, save the macro file as "S:RS.macros", and ReSource
will be configured every time that you run it.
KEY BINDINGS:
Every function in ReSource can be found in the menus.
You do not need to use any keys at all, but you probably will
want to. You can bind any function to any key. All Amiga keys
are supported, you may use shift, alt, ctl, lAmiga, rAmiga,
shift-alt, shift-ctl, alt-ctl, or shift-alt-ctl in combination
with any key, as a distinct key to bind a function to. Thus, you
have complete control over which keys do what. After re-binding
some keys, you will probably want to save the keytable. If you
save the keytable as "S:RS.keytable", it will be loaded every
time you run ReSource. You may want to create several keytables,
suitable for doing differing program types (C, assembler, etc.).
OPTIONS/Show offsets:
If this option is set to ON, all lines will start with
either a label, or the offset from the start of the file.
OPTIONS/Display Beep:
If this option is set to ON, the "BeepDisplay" function
is used to give feedback to the user, that either a function has
failed, or that a lengthy function has completed, and that the
user should now wake up.
OPTIONS/User Feedback:
If this option is set to ON, messages will appear in the
title bar, to let the user know what ReSource is doing,
especially while doing functions that take a lot of time,
extraordinary functions that only ReSource has direct control
over (such as dynamically allocating more memory for strings,
etc.), and also information about what hunks, etc., that it finds
in a load file.
OPTIONS/Feedback Delays:
If this option is set to ON, whenever a feedback message
is displayed, ReSource will wait for you to read the message,
before continuing. You will probably not want to keep this on
all the time, as it can slow down the disassembly process
somewhat, but while you are learning to use ReSource, it will
probably be very useful.
OPTIONS/Labels:
If this option is set to ON, labels will be displayed. This is
the default.
OPTIONS/Value symbols:
If this option is set to ON, value symbols will be displayed.
This is the default.
OPTIONS/End-of-line comments:
If this option is set to ON, end-of-line comments will be
displayed. This is the default.
OPTIONS/Full-line comments:
If this option is set to ON, full-line comments will be
displayed. This is the default.
****************************************************************
Don't forget to put arp.library in your LIBS: directory!
****************************************************************